#include "pieces.h"
#include "Plateau.h"
#include <iostream>
#include <cassert>


void supprimePiece(Plateau& p,const int& x, const int& y) /** supprime une piece */
{
    p.plat[x][y]=Vide;
}

bool deplacementTourB(const int& x1, const int& y1, Plateau& p, const int& x2, const int& y2)
{
    bool b=true;

    int i;
    if((p.plat[x2][y2]==Vide)||(p.plat[x2][y2]>7))
    {
    if((x1==x2) || (y1==y2))
                {
                    if (y1>y2) /** on se deplace vers la gauche */
                    {
                        for (i=y1-1;i>y2;i--)
                        {
                            if(p.plat[x1][i]!=Vide)
                            {b=false;}

                        }
                    }

                    if (y1<y2) /** on avance verticalement */
                    {
                        for (i=y1+1;i<y2;i++)
                        {
                            if(p.plat[x1][i]!=Vide)
                            {b=false;}
                        }
                    }

                    if (x1>x2) /**on se déplace vers la gauche */
                    {
                        for (i=x1-1;i>x2;i--)
                        {
                            if(p.plat[i][y1]!=Vide)
                            {b=false;}

                        }
                    }

                    if (x1<x2) /** on se déplace vers la droite */
                        {
                            for (i=x1+1;i<x2;i++)
                            {
                                if(p.plat[i][y1]!=Vide)
                                {b=false;}
                            }
                        }

                }
                else
                {
                    b=false;
                }
    }
    else
    {
        b=false;
    }

        return b;
}

bool deplacementTourN(const int& x1, const int& y1, Plateau& p, const int& x2, const int& y2)
{
    bool b=true;

    int i;
    if((p.plat[x2][y2]==Vide)||(p.plat[x2][y2]<7))
    {
    if((x1==x2) || (y1==y2))
                {
                    if (y1>y2) /**  on va vers le haut */
                    {
                        for (i=y1-1;i>y2;i--)
                        {
                            if(p.plat[x1][i]!=Vide)
                            {b=false;}

                        }
                    }

                    if (y1<y2) /** on va vers le bas */
                    {
                        for (i=y1+1;i<y2;i++)
                        {
                            if(p.plat[x1][i]!=Vide)
                            {b=false;}
                        }
                    }

                    if (x1>x2) /** on se déplace vers la gauche*/
                    {
                        for (i=x1-1;i>x2;i--)
                        {
                            if(p.plat[i][y1]!=Vide)
                            {b=false;}

                        }
                    }

                    if (x1<x2) /** on se déplace vers la droite */
                        {
                            for (i=x1+1;i<x2;i++)
                            {
                                if(p.plat[i][y1]!=Vide)
                                {b=false;}
                            }
                        }

                }
                else
                {
                    b=false;
                }
    }
    else
    {
        b=false;
    }

        return b;
}

bool deplacementFouB(const int& x1,const int& y1,Plateau& p,const int& x2,const int& y2)
{
    bool b=true;
    int i;
    if((p.plat[x2][y2]==Vide)||(p.plat[x2][y2]>7))
    {
if((p.plat[x1][y1]==1)&& ((p.plat[x2][y2]<7)))
    {
        b=false;
    }
    if((p.plat[x1][y1]==10)&& ((p.plat[x2][y2]>7)))
    {
        b=false;
    }
            if(x1>=x2 && y1>=y2) /** en bas à gauche */
            {
                if(x1-x2==y1-y2)
                {
                    for(i=1;i<x1-x2;i++)
                    {
                        if(p.plat[x1-i][y1-i]!=0)
                        {
                            b=false;
                        }

                    }
                }

                else b=false;
            }
            if(x1>=x2 && y1<=y2) /** en bas à droite */
            {
                if(x1-x2==y2-y1)
                {
                    for(i=1;i<x1-x2;++i)
                    {
                        if(p.plat[x1-i][y1+i]!=0)
                        {
                            b=false;
                        }
                    }
                }
                else b=false ;
            }
            if(x1<=x2 && y1<=y2)/** en haut à droite */
            {
                if(x2-x1==y2-y1)
                {
                    for(i=1;i<x2-x1;++i)
                    {
                        if(p.plat[x1+i][y1+i]!=0)
                        {
                            b=false;
                        }
                    }
                }
                else b=false;
            }
            if(x1<=x2 && y1>=y2) /** en haut à gauche */
            {
                if(x2-x1==y1-y2)
                {
                    for(i=1;i<x2-x1;++i)
                    {
                        if(p.plat[x1+i][y1-i]!=0)
                        {
                            b=false;
                        }
                    }
                }
                else b=false;
            }
    }
    else
    {
        b=false;
    }
    return b;

}

bool deplacementFouN(const int& x1,const int& y1,Plateau& p,const int& x2,const int& y2)
{
    bool b=true;
    int i;
    if((p.plat[x2][y2]==Vide)||(p.plat[x2][y2]<7))
    {
if((p.plat[x1][y1]==1)&& ((p.plat[x2][y2]<7)))
    {
        b=false;
    }
    if((p.plat[x1][y1]==10)&& ((p.plat[x2][y2]>7)))
    {
        b=false;
    }
            if(x1>=x2 && y1>=y2) /** en bas à gauche */
            {
                if(x1-x2==y1-y2)
                {
                    for(i=1;i<x1-x2;i++)
                    {
                        if(p.plat[x1-i][y1-i]!=0)
                        {
                            b=false;
                        }

                    }
                }

                else b=false;
            }
            if(x1>=x2 && y1<=y2) /** en bas à droite */
            {
                if(x1-x2==y2-y1)
                {
                    for(i=1;i<x1-x2;++i)
                    {
                        if(p.plat[x1-i][y1+i]!=0)
                        {
                            b=false;
                        }
                    }
                }
                else b=false ;
            }
            if(x1<=x2 && y1<=y2) /** en haut à droite */
            {
                if(x2-x1==y2-y1)
                {
                    for(i=1;i<x2-x1;++i)
                    {
                        if(p.plat[x1+i][y1+i]!=0)
                        {
                            b=false;
                        }
                    }
                }
                else b=false;
            }
            if(x1<=x2 && y1>=y2) /** en haut à gauche */
            {
                if(x2-x1==y1-y2)
                {
                    for(i=1;i<x2-x1;++i)
                    {
                        if(p.plat[x1+i][y1-i]!=0)
                        {
                            b=false;
                        }
                    }
                }
                else b=false;
            }
    }
    else
    {
        b=false;
    }
    return b;

}

bool pionAvanceB(const int& x1,const int&y1,Plateau& p,const int& x2,const int& y2)
{
    bool b=true;
    if(p.plat[x2][y2]==Vide)
    {

            if (x1==1)
                    {
                        if (!((y2==y1 && x2==x1+1) || (y2==y1 && x2==x1+2))||(p.plat[x2][y2]!=Vide))
                        b=false;
                    }
                    else
                    {
                        if (!((y2==y1) && x2==x1+1))
                        {b=false;}
                    }

    }
    if(p.plat[x2][y2]>7)
    {
        if(!((x2==x1+1) && (y2==y1+1) || (x2==x1+1) &&( y2==y1-1)))
        {
            b=false;
        }
    }
    if((p.plat[x2][y2]<7)&&(p.plat[x2][y2]!=0))
    {
        b=false;
    }
return b;
}

bool pionAvanceN(const int& x1,const int&y1,Plateau& p,const int& x2,const int& y2)
{
    bool b=true;
    if(p.plat[x2][y2]==Vide)
    {
        if (x1==6)
                    {
                        if (!((y2==y1 && x2==x1-1) || (y2==y1 && x2==x1-2))||(p.plat[x2][y2]!=Vide))
                        b=false;
                    }
                    else
                    {
                        if (!((y2==y1) && x2==x1-1))
                        {b=false;}
                    }

    }
    if((p.plat[x2][y2]<7)&&(p.plat[x2][y2]!=0))
    {
        if(!((x2==x1-1) && (y2==y1+1) || (x2==x1-1) &&( y2==y1-1)))
        {
            b=false;
        }
    }
    if((p.plat[x2][y2]>7))
    {
        b=false;
    }
return b;
}

bool cavalierAvanceB(const int& x1,const int&y1,Plateau& p,const int& x2,const int& y2)
{
    bool b=true;
    if((p.plat[x2][y2]==Vide)||(p.plat[x2][y2]>7))
    {
        if(!(((x2==x1+2) && (y2==y1+1)) || ((x2==x1-2) && (y2==y1-1)) || ((x2==x1+2) && (y2==y1-1)) || ((x2==x1-2) && (y2==y1+1)) ||
                    ((x2==x1+1) && (y2==y1+2)) || ((x2==x1-1) && (y2==y1-2)) || ((x2==x1+1) && (y2==y1-2)) || ((x2==x1-1) && (y2==y1+2))))

                { b=false; }
    }
    else
    {
        b=false;
    }
    return b;
}

bool cavalierAvanceN(const int& x1,const int&y1,Plateau& p,const int& x2,const int& y2)
{
    bool b=true;
    if((p.plat[x2][y2]==Vide)||(p.plat[x2][y2]<7))
    {
        if(!(((x2==x1+2) && (y2==y1+1)) || ((x2==x1-2) && (y2==y1-1)) || ((x2==x1+2) && (y2==y1-1)) || ((x2==x1-2) && (y2==y1+1)) ||
                    ((x2==x1+1) && (y2==y1+2)) || ((x2==x1-1) && (y2==y1-2)) || ((x2==x1+1) && (y2==y1-2)) || ((x2==x1-1) && (y2==y1+2))))

                { b=false; }
    }
    else
    {
        b=false;
    }
    return b;
}

bool roiAvanceB(const int& x1,const int&y1,Plateau& p,const int& x2,const int& y2)
{
    bool b=true;
    if((p.plat[x2][y2]==Vide)||(p.plat[x2][y2]>7))
    {;
        if(!((x2==x1)&((y2==y1+1)||(y2==y1-1)) || ((x1+1==x2)&((y1==y2)||(y1==y2+1)||(y2-1==y1))) || ((x1-1==x2)&((y1==y2)||(y1+1==y2)||(y1-1==y2)))))
                    {
                        b=false;
                    }
    }
    else
    {
        b=false;
    }

        return b;
}

bool roiAvanceN(const int& x1,const int&y1,Plateau& p,const int& x2,const int& y2)
{
     bool b=true;
    if((p.plat[x2][y2]==Vide)||(p.plat[x2][y2]<7))
    {
        if(!((x2==x1)&((y2==y1+1)||(y2==y1-1)) || ((x1+1==x2)&((y1==y2)||(y1==y2+1)||(y2-1==y1))) || ((x1-1==x2)&((y1==y2)||(y1+1==y2)||(y1-1==y2)))))
                    {
                        b=false;
                    }
    }
        else
        {
            b=false;
        }
        return b;
    }

bool piecePeutAvancer(const int& x1,const int& y1,Plateau& p,const int& x2,const int& y2) /** les déplacements possibles de chaque pièce*/
{
       bool b;

        switch (p.plat[x1][y1])
        {
            case TourB:

            b=deplacementTourB(x1,y1,p,x2,y2);

            break;

            case TourN:

            b=deplacementTourN(x1,y1,p,x2,y2);

            break;

            case CavalierB:

            b=cavalierAvanceB(x1,y1,p,x2,y2);

            break;

            case CavalierN:

            b=cavalierAvanceN(x1,y1,p,x2,y2);
            break;

            case FouB:

            b=deplacementFouB(x1,y1,p,x2,y2);

            break;

            case FouN:
            b=deplacementFouN(x1,y1,p,x2,y2);
            break;

            case DameB:/** la dame peut se deplacer dans toutes les directions */



            b=(deplacementFouB(x1,y1,p,x2,y2) || (deplacementTourB(x1,y1,p,x2,y2)));

            break;

            case DameN:

            b=((deplacementFouN(x1,y1,p,x2,y2)) || (deplacementTourN(x1,y1,p,x2,y2)));

            break;

            case RoiB:


            b=roiAvanceB(x1,y1,p,x2,y2);
            break;

            case RoiN:

            b=roiAvanceN(x1,y1, p, x2,y2);
            break;

            case PionB:


                b=pionAvanceB(x1,y1,p, x2, y2);
                break;

            case PionN:

            b=pionAvanceN(x1,y1,p,x2,y2);

                    break;

            case Vide:

               b=false;
                break;
        }

        return b;
}

bool piecePeutAvancer2(const int& x1,const int& y1,Plateau& p,const int& x2,const int& y2) /** verifie si la piece peut avancer en x2 y2 et verifie aussi si le roi n'est pas en echec apres ce mouvement*/
{
    int b=false;
    if(piecePeutAvancer(x1,y1,p,x2,y2)==false)
    {
        b=false;
    }
    if(piecePeutAvancer(x1,y1,p,x2,y2))
    {
        if (p.plat[x1][y1]<6 &&RoiEstEnEchecB(p,0,0))
        {
         typePiece c=p.plat[x2][y2];
         piecePriseOuAvance(x1,y1,p,x2,y2);
         b=!RoiEstEnEchecB(p,0,0);
         p.plat[x1][y1]=p.plat[x2][y2];
         p.plat[x2][y2]=c;
        }
        if(p.plat[x1][y1]<6 &&!RoiEstEnEchecB(p,0,0))
        {
            typePiece c=p.plat[x2][y2];
            piecePriseOuAvance(x1,y1,p,x2,y2);
            b=!RoiEstEnEchecB(p,0,0);
            p.plat[x1][y1]=p.plat[x2][y2];
            p.plat[x2][y2]=c;
        }
        if(p.plat[x1][y1]==RoiB)
        {
            b=!RoiEstEnEchecB(p,x2-x1,y2-y1);
        }
        if(p.plat[x1][y1]>7&& p.plat[x1][y1]!= RoiN&&RoiEstEnEchecN(p,0,0))
        {
            typePiece c=p.plat[x2][y2];
            piecePriseOuAvance(x1,y1,p,x2,y2);
            b=!RoiEstEnEchecN(p,0,0);
            p.plat[x1][y1]=p.plat[x2][y2];
            p.plat[x2][y2]=c;
        }
        if(p.plat[x1][y1]==RoiN)
        {
            b=!RoiEstEnEchecN(p,x2-x1,y2-y1);
        }
        if(p.plat[x1][y1]>7 &&!RoiEstEnEchecN(p,0,0)&&p.plat[x1][y1]!=RoiN)
        {
            typePiece c=p.plat[x2][y2];
            piecePriseOuAvance(x1,y1,p,x2,y2);
            b=!RoiEstEnEchecN(p,0,0);
            p.plat[x1][y1]=p.plat[x2][y2];
            p.plat[x2][y2]=c;
        }
    }
    return b;
}

void piecePriseOuAvance(const int& x1,const int& y1,Plateau& p,const int& x2,const int& y2) /**avance une piece si c'est possible */
{
    if(piecePeutAvancer(x1,y1,p,x2,y2))
                {
                    p.plat[x2][y2]=p.plat[x1][y1];
                    supprimePiece(p,x1,y1);
                }
}

void piecePriseOuAvance2(const int& x1,const int& y1,Plateau& p,const int& x2,const int& y2) /**avance une piece si c'est possible */
{
    if(piecePeutAvancer2(x1,y1,p,x2,y2))
                {
                    if(p.plat[x1][y1]==PionB)
                    {
                        if(x2==7)
                        {p.plat[x2][y2]=DameB;
                        supprimePiece(p,x1,y1);
                        }
                        if(x2!=7)
                        {
                            p.plat[x2][y2]=p.plat[x1][y1];
                            supprimePiece(p,x1,y1);
                        }
                    }
                    if(p.plat[x1][y1]==PionN)
                    {
                        if(x2==0)
                        {
                            p.plat[x2][y2]=DameN;
                            supprimePiece(p,x1,y1);
                        }
                        if(x2!=0)
                        {
                             p.plat[x2][y2]=p.plat[x1][y1];
                            supprimePiece(p,x1,y1);
                        }
                    }
                    if(p.plat[x1][y1]!=PionB&&p.plat[x1][y1]!=PionN)
                    {
                    piecePriseOuAvance(x1,y1,p,x2,y2);
                    }
                }
}

int positionyRoiB(Plateau&p) /**renvoi y du roi B*/
{
    int x,i,j;
    for(i=0;i<p.dimx;++i)
	{	for(j=0;j<p.dimy;++j)
        {
			    if(p.plat[i][j]==6)
			{
			    x=j;
			}
     }
	}
    return x;
}

int positionxRoiB(Plateau&p) /**renvoi x du roi B*/
{
    int x,i,j;
    for(i=0;i<p.dimx;++i)
	{	for(j=0;j<p.dimy;++j)
        {
			    if(p.plat[i][j]==6)
			{
			    x=i;
			}
     }
	}
    return x;
}

int positionyRoiN(Plateau&p) /**renvoi y du roi N*/
{
    int x,i,j;
    for(i=0;i<p.dimx;++i)
	{	for(j=0;j<p.dimy;++j)
        {
			    if(p.plat[i][j]==60)
			{
			    x=j;
			}
     }
	}
    return x;
}

int positionxRoiN(Plateau&p) /**renvoi x du roi N */
{
    int x,i,j;
    for(i=0;i<p.dimx;++i)
	{	for(j=0;j<p.dimy;++j)
        {
			    if(p.plat[i][j]==60)
			{
			    x=i;
			}
     }
	}
    return x;
}

bool RoiEstEnEchecB2(Plateau p,int a,int b) /** verifie si le roi B est en echec*/
{
    int echec=false;
    int x=positionxRoiB(p)+a;
    int y=positionyRoiB(p)+b;
    int i,j;
            for(i=0;i<p.dimx;++i)
            {	for(j=0;j<p.dimy;++j)
                {
                    if((piecePeutAvancer(i,j,p,x,y))&&(p.plat[i][j]>7))
                    {
                    echec=true;
                    }
                }
            }

  return echec;
}

bool RoiEstEnEchecB(Plateau p,int a,int b) /** verifie si le roi B est en echec si il bouge*/
{
    bool z=true;
    int x=positionxRoiB(p);
    int y=positionyRoiB(p);
    if(a==0&&b==0)
        {
            z=RoiEstEnEchecB2(p,0,0);
        }
    if(piecePeutAvancer(x,y,p,x+a,y+b))
        {
            typePiece c=p.plat[x+a][y+b];
            piecePriseOuAvance(x,y,p,x+a,y+b);
            z=RoiEstEnEchecB2(p,0,0);
            piecePriseOuAvance(x+a,y+b,p,x,y);
            p.plat[x+a][y+b]=c;
        }

    return z;

}

bool RoiEstEnEchecN2(Plateau& p,int a,int b)/** verifie si le roi N est en echec*/
{
   bool echec=false;

  int x=positionxRoiN(p)+a;
  int y=positionyRoiN(p)+b;
  int i,j;
  for(i=0;i<p.dimx;++i)
	{	for(j=0;j<p.dimy;++j)
        {
            if(piecePeutAvancer(i,j,p,x,y)==true)
            {
                echec=true;
            }
        }
	}
  return echec;

}

bool RoiEstEnEchecN(Plateau& p,int a,int b) /**verifie si le roi N est en echec si il bouge*/
{
    bool z=true;
    int x=positionxRoiN(p);
    int y=positionyRoiN(p);
    if(a==0&&b==0)
        {
            z=RoiEstEnEchecN2(p,0,0);
        }
    if(piecePeutAvancer(x,y,p,x+a,y+b))
        {
            typePiece c=p.plat[x+a][y+b];
            piecePriseOuAvance(x,y,p,x+a,y+b);
            z=RoiEstEnEchecN2(p,0,0);
            piecePriseOuAvance(x+a,y+b,p,x,y);
            p.plat[x+a][y+b]=c;

        }

    return z;

}

int positionxPieceEchecB(Plateau&p) /** renvoi x de la pieceN qui fait echec*/
{
    int echec;
    int x=positionxRoiB(p);
    int y=positionyRoiB(p);
    int i,j;
        for(i=0;i<p.dimx;++i)
        {	for(j=0;j<p.dimy;++j)
            {
                if((piecePeutAvancer(i,j,p,x,y)==true)&&(p.plat[i][j]>7))
                {
                echec=i;
                }
            }
        }
    return echec;
}

int positionxPieceEchecN(Plateau&p) /** renvoi x de la pieceB qui fait echec*/
{
    int echec;
    int x=positionxRoiN(p);
    int y=positionyRoiN(p);
    int i,j;
        for(i=0;i<p.dimx;++i)
        {	for(j=0;j<p.dimy;++j)
            {
                if((piecePeutAvancer(i,j,p,x,y)==true)&&(p.plat[i][j]<7))
                {
                echec=i;
                }
            }
        }
    return echec;
}

int positionyPieceEchecB(Plateau&p) /**renvoie y de la pieceN qui fait echec*/
{
    int echec;
    int x=positionxRoiB(p);
    int y=positionyRoiB(p);
    int i,j;
        for(i=0;i<p.dimx;++i)
        {	for(j=0;j<p.dimy;++j)
            {
                if((piecePeutAvancer(i,j,p,x,y)==true)&&(p.plat[i][j]>7))
                {
                echec=j;
                }
            }
        }
    return echec;
}

int positionyPieceEchecN(Plateau&p) /** renvoie y de la pieceB qui fait echec*/
{
    int echec;
    int x=positionxRoiN(p);
    int y=positionyRoiN(p);
    int i,j;
        for(i=0;i<p.dimx;++i)
        {	for(j=0;j<p.dimy;++j)
            {
                if((piecePeutAvancer(i,j,p,x,y)==true)&&(p.plat[i][j]<7))
                {
                echec=j;
                }
            }
        }
    return echec;
}

bool PiecePeutPrendreB(Plateau&p) /**renvoi vrai si une pieceB peut prendre la piece qui fait echec*/
{
    assert(RoiEstEnEchecB(p,0,0)==true);
    bool b=false;
    int x=positionxPieceEchecB(p);
    int y=positionyPieceEchecB(p);
    int i,j;
        for(i=0;i<p.dimx;++i)
        {	for(j=0;j<p.dimy;++j)
            {
                if(piecePeutAvancer2(i,j,p,x,y))
                {
                b=true;
                }
            }
        }
  return b;
}

bool PiecePeutPrendreN(Plateau&p) /**renvoi vrai si une pieceN peut prendre la piece qui fait echec*/
{
    assert(RoiEstEnEchecN(p,0,0)==true);
    bool b=false;
    int x=positionxPieceEchecN(p);
    int y=positionyPieceEchecN(p);
    int i,j;
        for(i=0;i<p.dimx;++i)
        {	for(j=0;j<p.dimy;++j)
            {
                if(piecePeutAvancer2(i,j,p,x,y))
                {
                b=true;
                }
            }
        }
  return b;
}

bool unePiecePeutAvancerB(Plateau&p,int x,int y) /** verifie si une piece blanche peut aller en x y*/
{
    bool b=false;
    int i,j;
        for(i=0;i<p.dimx;++i)
        {
            for(j=0;j<p.dimy;++j)
            {
                if(piecePeutAvancer2(i,j,p,x,y)&&(p.plat[i][j]<6))
                {
                    b=true;
                }
            }
        }
    return b;
}

bool unePiecePeutAvancerN(Plateau&p,int x,int y) /** verifie si une piece noir peut aller en x y*/
{
    bool b=false;
    int i,j;
        for(i=0;i<p.dimx;++i)
        {
            for(j=0;j<p.dimy;++j)
            {
                if(piecePeutAvancer2(i,j,p,x,y)&&(p.plat[i][j]>7))
                {
                    b=true;
                }
            }
        }
    return b;
}

bool conditionTourN(Plateau&p) /** verifie si une piece peut intercepter l'echec de la tour noir(renvoi vrai si aucune piece peut intercepter)*/
{
    int b=false;
    int x1=positionxPieceEchecB(p);
    int y1=positionyPieceEchecB(p);
    int x2=positionxRoiB(p);
    int y2=positionyRoiB(p);
    int i;
        if((x1==x2) || (y1==y2))
    { b=true;
                if (y1>y2) /** on se deplace vers la gauche*/
                    {
                        for (i=y1-1;i>y2;i--)
                        {
                            if(unePiecePeutAvancerB(p,x1,i))
                            {b=false;}

                        }
                    }

                    if (y1<y2) /** on se deplace vers la droite*/
                    {
                        for (i=y1+1;i<y2;i++)
                        {
                            if(unePiecePeutAvancerB(p,x1,i))
                            {b=false;}
                        }
                    }

                    if (x1>x2) /** on se déplace vers le bas*/
                    {
                        for (i=x1-1;i>x2;i--)
                        {
                            if(unePiecePeutAvancerB(p,i,y1))
                            {b=false;}

                        }
                    }

                    if (x1<x2) /** on se déplace vers le haut*/
                        {
                            for (i=x1+1;i<x2;i++)
                            {
                                if(unePiecePeutAvancerB(p,i,y1))
                                {b=false;}
                            }
                        }



    }
        return b;
}

bool conditionTourB(Plateau&p) /** verifie si une piece peut intercepter l'echec de la tour blanche(renvoi vrai si aucune piece peut intercepter)*/
{
    int b=false;
    int x1=positionxPieceEchecN(p);
    int y1=positionyPieceEchecN(p);
    int x2=positionxRoiN(p);
    int y2=positionyRoiN(p);
    int i;
        if((x1==x2) || (y1==y2))
    { b=true;
                if (y1>y2) /** on se deplace vers la gauche*/
                    {
                        for (i=y1-1;i>y2;i--)
                        {
                            if(unePiecePeutAvancerN(p,x1,i))
                            {b=false;}

                        }
                    }

                    if (y1<y2) /** on se deplace vers la droite*/
                    {
                        for (i=y1+1;i<y2;i++)
                        {
                            if(unePiecePeutAvancerN(p,x1,i))
                            {b=false;}
                        }
                    }

                    if (x1>x2) /**on se déplace vers le bas*/
                    {
                        for (i=x1-1;i>x2;i--)
                        {
                            if(unePiecePeutAvancerN(p,i,y1))
                            {b=false;}

                        }
                    }

                    if (x1<x2) /** on se déplace vers le haut*/
                        {
                            for (i=x1+1;i<x2;i++)
                            {
                                if(unePiecePeutAvancerN(p,i,y1))
                                {b=false;}
                            }
                        }



    }
        return b;
}

bool conditionFouN(Plateau&p) /** verifie si une piece peut intercepter l'echec du fou noir(renvoi vrai si aucune piece peut intercepter)*/
{

    int x1=positionxPieceEchecB(p);
    int y1=positionyPieceEchecB(p);
    int x2=positionxRoiB(p);
    int y2=positionyRoiB(p);
    int b=false;
    int i;
        if(p.plat[x1][y1]==FouN || p.plat[x1][y1]==DameN)
        {   b=true;
                if(x1>=x2 && y1>=y2)
                {
                    if(x1-x2==y1-y2)
                    {
                        for(i=1;i<x1-x2;i++)
                        {
                            if(unePiecePeutAvancerB(p,x1-i,y1-i))
                            {
                            b=false;
                            }

                        }
                    }


                }
                if(x1>=x2 && y1<=y2)
                {
                    if(x1-x2==y2-y1)
                    {
                        for(i=1;i<x1-x2;++i)
                        {
                            if(unePiecePeutAvancerB(p,x1-i,y1+i))
                            {
                                b=false;
                            }
                        }
                    }

                }
                if(x1<=x2 && y1<=y2)
                {
                    if(x2-x1==y2-y1)
                    {
                        for(i=1;i<x2-x1;++i)
                        {
                            if(unePiecePeutAvancerB(p,x1+i,y1+i))
                            {
                                b=false;
                            }
                        }
                    }

                }
                if(x1<=x2 && y1>=y2)
                {
                    if(x2-x1==y1-y2)
                    {
                        for(i=1;i<x2-x1;++i)
                        {
                            if(unePiecePeutAvancerB(p,x1+i,y1-i))
                            {
                                b=false;
                            }
                        }
                    }

                }


        }

    return b;
}

bool conditionFouB(Plateau&p) /** verifie si une piece peut intercepter l'echec du fou noir(renvoi vrai si aucune piece peut intercepter)*/
{

    int x1=positionxPieceEchecN(p);
    int y1=positionyPieceEchecN(p);
    int x2=positionxRoiN(p);
    int y2=positionyRoiN(p);
    int b=false;
    int i;
        if(p.plat[x1][y1]==FouB||p.plat[x1][y1]==DameB)
        {   b=true;
                if(x1>=x2 && y1>=y2)
                {
                    if(x1-x2==y1-y2)
                    {
                        for(i=1;i<x1-x2;i++)
                        {
                            if(unePiecePeutAvancerN(p,x1-i,y1-i))
                            {
                            b=false;
                            }

                        }
                    }


                }
                if(x1>=x2 && y1<=y2)
                {
                    if(x1-x2==y2-y1)
                    {
                        for(i=1;i<x1-x2;++i)
                        {
                            if(unePiecePeutAvancerN(p,x1-i,y1+i))
                            {
                                b=false;
                            }
                        }
                    }

                }
                if(x1<=x2 && y1<=y2)
                    {if(x2-x1==y2-y1)
                    {
                        for(i=1;i<x2-x1;++i)
                        {
                            if(unePiecePeutAvancerN(p,x1+i,y1+i))
                            {
                                b=false;
                            }
                        }
                    }

                }
                if(x1<=x2 && y1>=y2)
                {
                    if(x2-x1==y1-y2)
                    {
                        for(i=1;i<x2-x1;++i)
                        {
                            if(unePiecePeutAvancerN(p,x1+i,y1-i))
                            {
                                b=false;
                            }
                        }
                    }

                }


        }

    return b;
}

bool interceptionPossibleB(Plateau&p) /** renvoi vrai si une piece B peut intercepter ou prendre*/
{
    bool b=false;
    int x=positionxPieceEchecB(p);
    int y=positionyPieceEchecB(p);

    switch(p.plat[x][y])
    {
        case PionN:
        b=PiecePeutPrendreB(p);
        break;

        case CavalierN:
        b=PiecePeutPrendreB(p);
        break;

        case TourN:
        b=PiecePeutPrendreB(p)||!conditionTourN(p);
        break;

        case FouN:
        b=PiecePeutPrendreB(p)||!conditionFouN(p);
        break;

        case DameN:
        b=PiecePeutPrendreB(p)||(!conditionFouN(p)&&!conditionTourN(p));
        break;

        return b;
    }
 }

bool interceptionPossibleN(Plateau&p) /** renvoi vrai si une piece N peut intercepter ou prendre*/
{
    bool b=false;
    int x=positionxPieceEchecN(p);
    int y=positionyPieceEchecN(p);

    switch(p.plat[x][y])
    {
        case PionB:
        b=PiecePeutPrendreN(p);
        break;

        case CavalierB:
        b=PiecePeutPrendreN(p);
        break;

        case TourB:
        b=PiecePeutPrendreN(p)||!conditionTourB(p);
        break;

        case FouB:
        b=PiecePeutPrendreN(p)||!conditionFouB(p);
        break;

        case DameB:
        b=PiecePeutPrendreN(p)||(!conditionFouB(p)&&!conditionTourB(p));
        break;

        return b;
    }
 }

bool echecEtMatRoiB(Plateau&p) /** revnoi vrai si B mat*/
{
    int b=false;
    if(!RoiEstEnEchecB(p,0,0))
    {
      b=false;
    }
    else
    {int x=positionxRoiB(p);
    int y=positionyRoiB(p);
    assert(platEstPositionPieceValide(p,x,y));

        if(x==7&&y==7)
        {
            if(RoiEstEnEchecB(p,0,0) &&(!(piecePeutAvancer2(x,y,p,x-1,y)) || (RoiEstEnEchecB(p,-1,0)))&&(!(piecePeutAvancer2(x,y,p,x,y-1)) || (RoiEstEnEchecB(p,0,0-1)))&&(!(piecePeutAvancer2(x,y,p,x-1,y-1)) || (RoiEstEnEchecB(p,-1,-1))))
            {
                b=!interceptionPossibleB(p);
            }
        }
        if(x==7&&y==0)
        {
            if(RoiEstEnEchecB(p,0,0) && (!(piecePeutAvancer2(x,y,p,x-1,y)) || (RoiEstEnEchecB(p,-1,0)))&&(!(piecePeutAvancer2(x,y,p,x,y+1)) || (RoiEstEnEchecB(p,0,1)))&&(!(piecePeutAvancer2(x,y,p,x-1,y+1)) || (RoiEstEnEchecB(p,-1,1))))
            {
                 b=!interceptionPossibleB(p);
            }
        }
       if(x==7&&y!=0&&y!=7)
        {
            if(RoiEstEnEchecB(p,0,0) && (!(piecePeutAvancer2(x,y,p,x-1,y)) || (RoiEstEnEchecB(p,-1,0)))&&(!(piecePeutAvancer2(x,y,p,x,y+1)) || (RoiEstEnEchecB(p,0,1)))&&(!(piecePeutAvancer2(x,y,p,x,y-1)) || (RoiEstEnEchecB(p,0,0-1)))&&(!(piecePeutAvancer2(x,y,p,x-1,y+1)) || (RoiEstEnEchecB(p,-1,1)))&&(!(piecePeutAvancer2(x,y,p,x-1,y-1)) || (RoiEstEnEchecB(p,-1,-1))))
            {
                 b=!interceptionPossibleB(p);
            }
        }

        if(x==0&&y==7)
        {
            if(RoiEstEnEchecB(p,0,0)&&(!(piecePeutAvancer2(x,y,p,x+1,y)) || (RoiEstEnEchecB(p,1,0))) &&(!(piecePeutAvancer2(x,y,p,x,y-1)) || (RoiEstEnEchecB(p,0,0-1)))&&(!(piecePeutAvancer2(x,y,p,x+1,y-1)) || (RoiEstEnEchecB(p,1,-1))))
            {
                 b=!interceptionPossibleB(p);
            }
        }
        if(x==0&&y==0)
        {
             if(RoiEstEnEchecB(p,0,0)&& (!(piecePeutAvancer2(x,y,p,x+1,y)) || (RoiEstEnEchecB(p,1,0))) &&(!(piecePeutAvancer2(x,y,p,x,y+1)) || (RoiEstEnEchecB(p,0,1)))&&(!(piecePeutAvancer2(x,y,p,x+1,y+1)) || (RoiEstEnEchecB(p,1,1))))
            {
                 b=!interceptionPossibleB(p);
            }
        }
        if(x==0&&y!=7&&y!=0)
        {
            if(RoiEstEnEchecB(p,0,0) && (!(piecePeutAvancer2(x,y,p,x+1,y)) || (RoiEstEnEchecB(p,1,0))) &&(!(piecePeutAvancer2(x,y,p,x,y+1)) || (RoiEstEnEchecB(p,0,1)))&&(!(piecePeutAvancer2(x,y,p,x,y-1)) || (RoiEstEnEchecB(p,0,0-1)))&&(!(piecePeutAvancer2(x,y,p,x+1,y+1)) || (RoiEstEnEchecB(p,1,1)))&&(!(piecePeutAvancer2(x,y,p,x+1,y-1)) || (RoiEstEnEchecB(p,1,-1))))
            {
                b=!interceptionPossibleB(p);
            }
        }

     if(y==7&&x!=0&&x!=7)
     {
            if(RoiEstEnEchecB(p,0,0) && (!(piecePeutAvancer2(x,y,p,x+1,y)) || (RoiEstEnEchecB(p,1,0))) &&(!(piecePeutAvancer2(x,y,p,x-1,y)) || (RoiEstEnEchecB(p,-1,0)))&&(!(piecePeutAvancer2(x,y,p,x,y-1)) || (RoiEstEnEchecB(p,0,0-1)))&&(!(piecePeutAvancer2(x,y,p,x+1,y-1)) || (RoiEstEnEchecB(p,1,-1)))&&(!(piecePeutAvancer2(x,y,p,x-1,y-1)) || (RoiEstEnEchecB(p,-1,-1))))
            {
                 b=!interceptionPossibleB(p);
            }
     }
     if(y==0&&x!=0&&x!=7)
     {
        if(RoiEstEnEchecB(p,0,0)&& (!(piecePeutAvancer2(x,y,p,x+1,y)) || (RoiEstEnEchecB(p,1,0))) &&(!(piecePeutAvancer2(x,y,p,x-1,y)) || (RoiEstEnEchecB(p,-1,0)))&&(!(piecePeutAvancer2(x,y,p,x,y+1)) || (RoiEstEnEchecB(p,0,1)))&&(!(piecePeutAvancer2(x,y,p,x+1,y+1)) || (RoiEstEnEchecB(p,1,1))) && (!(piecePeutAvancer2(x,y,p,x-1,y+1)) || (RoiEstEnEchecB(p,-1,1))))
            {
                b=!interceptionPossibleB(p);
            }
     }
     if(y!=7 && y!=0 && x!=0 &&x!=7)
     {
        if(RoiEstEnEchecB(p,0,0) && (!(piecePeutAvancer2(x,y,p,x+1,y)) || (RoiEstEnEchecB(p,1,0))) &&(!(piecePeutAvancer2(x,y,p,x-1,y)) || (RoiEstEnEchecB(p,-1,0)))&&(!(piecePeutAvancer2(x,y,p,x,y+1)) || (RoiEstEnEchecB(p,0,1)))&&(!(piecePeutAvancer2(x,y,p,x,y-1)) || (RoiEstEnEchecB(p,0,0-1)))&&(!(piecePeutAvancer2(x,y,p,x+1,y+1)) || (RoiEstEnEchecB(p,1,1)))&&(!(piecePeutAvancer2(x,y,p,x+1,y-1)) || (RoiEstEnEchecB(p,1,-1)))&&(!(piecePeutAvancer2(x,y,p,x-1,y+1)) || (RoiEstEnEchecB(p,-1,1)))&&(!(piecePeutAvancer2(x,y,p,x-1,y-1)) || (RoiEstEnEchecB(p,-1,-1))))
            {
                 b=!interceptionPossibleB(p);
            }
     }
    }
    return b;
}

bool echecEtMatRoiN(Plateau&p) /** revnoi vrai si N mat*/
{
    bool b=false;
    if(!RoiEstEnEchecN(p,0,0))
    {
      b=false;
    }
    else
    {int x=positionxRoiN(p);
    int y=positionyRoiN(p);
    assert(platEstPositionPieceValide(p,x,y));

        if(x==7&&y==7)
        {
            if(RoiEstEnEchecN(p,0,0) &&(!(piecePeutAvancer2(x,y,p,x-1,y)) || (RoiEstEnEchecN(p,-1,0)))&&(!(piecePeutAvancer2(x,y,p,x,y-1)) || (RoiEstEnEchecN(p,0,0-1)))&&(!(piecePeutAvancer2(x,y,p,x-1,y-1)) || (RoiEstEnEchecN(p,-1,-1))))
            {
                b=!interceptionPossibleN(p);
            }
        }
        if(x==7&&y==0)
        {
            if(RoiEstEnEchecN(p,0,0) && (!(piecePeutAvancer2(x,y,p,x-1,y)) || (RoiEstEnEchecN(p,-1,0)))&&(!(piecePeutAvancer2(x,y,p,x,y+1)) || (RoiEstEnEchecN(p,0,1)))&&(!(piecePeutAvancer2(x,y,p,x-1,y+1)) || (RoiEstEnEchecN(p,-1,1))))
            {
                 b=!interceptionPossibleN(p);
            }
        }
       if(x==7&&y!=0&&y!=7)
        {
            if(RoiEstEnEchecN(p,0,0) && (!(piecePeutAvancer2(x,y,p,x-1,y)) || (RoiEstEnEchecN(p,-1,0)))&&(!(piecePeutAvancer2(x,y,p,x,y+1)) || (RoiEstEnEchecN(p,0,1)))&&(!(piecePeutAvancer2(x,y,p,x,y-1)) || (RoiEstEnEchecN(p,0,0-1)))&&(!(piecePeutAvancer2(x,y,p,x-1,y+1)) || (RoiEstEnEchecN(p,-1,1)))&&(!(piecePeutAvancer2(x,y,p,x-1,y-1)) || (RoiEstEnEchecN(p,-1,-1))))
            {
                  b=!interceptionPossibleN(p);
            }
        }

        if(x==0&&y==7)
        {
            if(RoiEstEnEchecN(p,0,0)&&(!(piecePeutAvancer2(x,y,p,x+1,y)) || (RoiEstEnEchecN(p,1,0))) &&(!(piecePeutAvancer2(x,y,p,x,y-1)) || (RoiEstEnEchecN(p,0,0-1)))&&(!(piecePeutAvancer2(x,y,p,x+1,y-1)) || (RoiEstEnEchecN(p,1,-1))))
            {
                b=!interceptionPossibleN(p);;
            }
        }
        if(x==0&&y==0)
        {
             if(RoiEstEnEchecN(p,0,0)&& (!(piecePeutAvancer2(x,y,p,x+1,y)) || (RoiEstEnEchecN(p,1,0))) &&(!(piecePeutAvancer2(x,y,p,x,y+1)) || (RoiEstEnEchecN(p,0,1)))&&(!(piecePeutAvancer2(x,y,p,x+1,y+1)) || (RoiEstEnEchecN(p,1,1))))
            {
                b=!interceptionPossibleN(p);
            }
        }
        if(x==0&&y!=7&&y!=0)
        {
            if(RoiEstEnEchecN(p,0,0) && (!(piecePeutAvancer2(x,y,p,x+1,y)) || (RoiEstEnEchecN(p,1,0))) &&(!(piecePeutAvancer2(x,y,p,x,y+1)) || (RoiEstEnEchecN(p,0,1)))&&(!(piecePeutAvancer2(x,y,p,x,y-1)) || (RoiEstEnEchecN(p,0,0-1)))&&(!(piecePeutAvancer2(x,y,p,x+1,y+1)) || (RoiEstEnEchecN(p,1,1)))&&(!(piecePeutAvancer2(x,y,p,x+1,y-1)) || (RoiEstEnEchecN(p,1,-1))))
            {
                  b=!interceptionPossibleN(p);
            }
        }

     if(y==7&&x!=0&&x!=7)
     {
            if(RoiEstEnEchecN(p,0,0) && (!(piecePeutAvancer2(x,y,p,x+1,y)) || (RoiEstEnEchecN(p,1,0))) &&(!(piecePeutAvancer2(x,y,p,x-1,y)) || (RoiEstEnEchecN(p,-1,0)))&&(!(piecePeutAvancer2(x,y,p,x,y-1)) || (RoiEstEnEchecN(p,0,0-1)))&&(!(piecePeutAvancer2(x,y,p,x+1,y-1)) || (RoiEstEnEchecN(p,1,-1)))&&(!(piecePeutAvancer2(x,y,p,x-1,y-1)) || (RoiEstEnEchecN(p,-1,-1))))
            {
                  b=!interceptionPossibleN(p);
            }
     }
     if(y==0&&x!=0&&x!=7)
     {
        if(RoiEstEnEchecN(p,0,0)&& (!(piecePeutAvancer2(x,y,p,x+1,y)) || (RoiEstEnEchecN(p,1,0))) &&(!(piecePeutAvancer2(x,y,p,x-1,y)) || (RoiEstEnEchecN(p,-1,0)))&&(!(piecePeutAvancer2(x,y,p,x,y+1)) || (RoiEstEnEchecN(p,0,1)))&&(!(piecePeutAvancer2(x,y,p,x+1,y+1)) || (RoiEstEnEchecN(p,1,1))) && (!(piecePeutAvancer2(x,y,p,x-1,y+1)) || (RoiEstEnEchecN(p,-1,1))))
            {
                 b=!interceptionPossibleN(p);
            }
     }
     if(y!=7 && y!=0 && x!=0 &&x!=7)
     {
        if(RoiEstEnEchecN(p,0,0) && (!(piecePeutAvancer2(x,y,p,x+1,y)) || (RoiEstEnEchecN(p,1,0))) &&(!(piecePeutAvancer2(x,y,p,x-1,y)) || (RoiEstEnEchecN(p,-1,0)))&&(!(piecePeutAvancer2(x,y,p,x,y+1)) || (RoiEstEnEchecN(p,0,1)))&&(!(piecePeutAvancer2(x,y,p,x,y-1)) || (RoiEstEnEchecN(p,0,0-1)))&&(!(piecePeutAvancer2(x,y,p,x+1,y+1)) || (RoiEstEnEchecN(p,1,1)))&&(!(piecePeutAvancer2(x,y,p,x+1,y-1)) || (RoiEstEnEchecN(p,1,-1)))&&(!(piecePeutAvancer2(x,y,p,x-1,y+1)) || (RoiEstEnEchecN(p,-1,1)))&&(!(piecePeutAvancer2(x,y,p,x-1,y-1)) || (RoiEstEnEchecN(p,-1,-1))))
            {
                  b=!interceptionPossibleN(p);
            }
     }
    }
    return b;
}
